home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / HSI2ARR.ZIP / HSI2ARR.C < prev    next >
C/C++ Source or Header  |  1994-08-17  |  8KB  |  205 lines
  1. /* HSI2ARR.C -- Coded by Darion.  August 16th, 1994
  2.  * Converts IMAGE ALCHEMY'S HSI RAW format + palette to C arrays
  3.  * And defines.  Coded by Darion (thimj@u.washington.edu) 8-16-94
  4.  * Any Questions?  email me..                                     */
  5.  
  6. #include <stdio.h>      /* the standards */
  7. #include <dos.h>
  8. #include <stdlib.h>
  9.  
  10.  
  11. void help(int);        /* prototyping is wonderful :) */
  12. int getWord(FILE *stream);
  13.  
  14. /* this header was taken right out of the back of the manual */
  15.  
  16. typedef struct {
  17.     char magicnum[6];           /* magic numbers for verifying file */
  18.     int version;                /* current version of format.. Currently 4 */
  19.     int width;                  /* width of picture */
  20.     int height;                 /* height of picture */
  21.     int palsize;                /* number of colors */
  22.     int hordpi;                 /* horizontal dots per inch */
  23.     int verdpi;                 /* vertical dots per inch */
  24.     int gamma;                  /* gamma factor */
  25.     char reserved[12];          /* reserved for future use */
  26.     } HSIRAW;
  27.  
  28. HSIRAW rawhdr;                  /* creates one (1) structure of type HSIRAW */
  29. unsigned char *paldata;         /* unsigned char pointer to be filled in later */
  30. unsigned char *picdata;         /* buffer for holding picture data */
  31.  
  32. void main(int argc, char *argv[])
  33. {
  34.  
  35.     FILE *fp, *fp1;             /* File pointers for infile and outfile respectively */
  36.     int x, temp, temp1=0,z;
  37.     int value,blah;            /* generic variables */
  38.  
  39.     if(argc < 2) help(1);        /* if they think they have a interface, yell at em */
  40.  
  41.     if ((fp = fopen(argv[1], "rb"))== NULL) /* open .RAW file for read+binary */
  42.         {
  43.         fprintf(stderr, "Cannot open input file.\n"); /* catch any errors */
  44.         help(2);
  45.         }
  46.     fread(rawhdr.magicnum, 6 , 1, fp);  /* read in the first 6 bytes, the 'magicnumbers' */
  47.     rawhdr.version = getWord(fp);        /* read in the rest of the header */
  48.     rawhdr.width = getWord(fp);        /* must use special function to get int's */
  49.     rawhdr.height = getWord(fp);        /* function pulled from back of Image Alchemy manual */
  50.     rawhdr.palsize = getWord(fp);        /* it reads any int on any OS the same */
  51.     rawhdr.hordpi = getWord(fp);
  52.     rawhdr.verdpi = getWord(fp);
  53.     rawhdr.gamma = getWord(fp);
  54.     fread(rawhdr.reserved, 12, 1, fp);
  55.  
  56. /* this code below validates file, checking the magicnumbers */
  57.  
  58.     if(rawhdr.magicnum[0] != 0x6d || rawhdr.magicnum[1] != 0x68 ||
  59.        rawhdr.magicnum[2] != 0x77 || rawhdr.magicnum[3] != 0x61 ||
  60.        rawhdr.magicnum[4] != 0x6e || rawhdr.magicnum[5] != 0x68)
  61.         {
  62.         fprintf(stderr, "Invalid HSI-RAW file.\n");
  63.         help(3);
  64.         }
  65. /* allocate space for the palette...  the size of the space allocated must be
  66.  * equal to THREE times the amount of colors in the picture.  This is because
  67.  * three BYTE sized values make up ONE palette entry */
  68.  
  69.     paldata = (char *)malloc(rawhdr.palsize*3);
  70.  
  71. /* read in the palette, it is the LAST thing after the header.  So
  72.  * you have a 32 byte header, then the palette, then image data.  */
  73.  
  74.     fread(paldata, rawhdr.palsize * 3, 1, fp);
  75. /* shifts all the palette values right two bits, so they conform with
  76.  * they can be used properly.  0-63 are valid values, not 63-255.  Shifting
  77.  * rid of the upper two bits */
  78.  
  79.     for(x = 0;x < rawhdr.palsize * 3;x++)
  80.         paldata[x] = paldata[x] >> 2;
  81.  
  82. /* allocate space for the picture buffer.  I just used the width of the
  83.  * picture for the size */
  84.  
  85.     picdata = (char *)malloc(rawhdr.width);
  86.  
  87. /* debug info.. if you want to 'mess' with the code a little bit, I hope this
  88.  * can help        */
  89.  
  90. #ifdef DEBUG
  91.     printf("Palsize: %d\n", rawhdr.palsize);
  92.     printf("Allocated: %d\n", rawhdr.palsize * 3);
  93.     printf("Version: %d\n", rawhdr.version);
  94.     printf("Width: %d\n", rawhdr.width);
  95.     printf("Height: %d\n", rawhdr.height);
  96.     printf("Hordpi: %d\n", rawhdr.hordpi);
  97.     printf("Verdpi: %d\n", rawhdr.verdpi);
  98.     printf("Gamma: %d\n", rawhdr.gamma);
  99. #endif
  100.  
  101. #ifdef DEBUG
  102.     for(temp=0;temp < rawhdr.palsize * 3;temp +=3)
  103.         printf("Pal Data: %d %d %d\n", paldata[temp], paldata[temp+1], paldata[temp+2]);
  104. #endif
  105.  
  106. /* check for and open output file */
  107.     if ((fp1 = fopen(argv[2], "wb"))== NULL)
  108.         {
  109.         fprintf(stderr, "Cannot open output file.\n");
  110.         help(4);
  111.         }
  112.  
  113. /* begin to output to file, you can customize your own output files here */
  114. /* fprintf is easy, prints formatted text into a stream, in this case a file */
  115.  
  116.     fprintf(fp1,"#define PICDATA_COLORS %d\n", rawhdr.palsize);
  117.     fprintf(fp1,"#define PICDATA_HORDPI %d\n", rawhdr.hordpi);
  118.     fprintf(fp1,"#define PICDATA_VERDPI %d\n", rawhdr.verdpi);
  119.     fprintf(fp1,"#define PICDATA_GAMMA %d\n", rawhdr.gamma);
  120.     fprintf(fp1,"#define PICDATA_WIDTH %d\n", rawhdr.width);
  121.     fprintf(fp1,"#define PICDATA_HEIGHT %d\n", rawhdr.height);
  122.     fprintf(fp1,"unsigned char PALDATA[%d] = {\n",rawhdr.palsize * 3);
  123. /* set up the loop in which we will print out our palette data */
  124. /* I just loop from 0 to 765 right here, leaving 3 so I can terminate the */
  125. /* array properly */
  126.  
  127.     temp = 0;
  128.     for(temp=0;temp < ((rawhdr.palsize * 3)-3);temp += 15)
  129.         {
  130.         fprintf(fp1, "%d,%d,%d, ", paldata[temp], paldata[temp+1], paldata[temp+2]);
  131.         fprintf(fp1, "%d,%d,%d, ", paldata[temp+3], paldata[temp+4], paldata[temp+5]);
  132.         fprintf(fp1, "%d,%d,%d, ", paldata[temp+6], paldata[temp+7], paldata[temp+8]);
  133.         fprintf(fp1, "%d,%d,%d, ", paldata[temp+9], paldata[temp+10], paldata[temp+11]);
  134.         fprintf(fp1, "%d,%d,%d,\n", paldata[temp+12], paldata[temp+13], paldata[temp+14]);
  135.         }
  136. /* terminate the array properly */
  137.  
  138.     fprintf(fp1, "%d,%d,%d };\n\n", paldata[temp], paldata[temp+1], paldata[temp+2]);
  139. /* start with the picture data */
  140.  
  141.     fprintf(fp1,"char PICDATA[%d][%d] = {\n",rawhdr.height, rawhdr.width);
  142.     printf("\n\nConverting... ");
  143. /* Basically same process.  I pulled a few tricks to make sure that the lines
  144.  * didnt get OUTRAGEOUSLY long.  Kinda sloppy, but it gets the job done!
  145.  * I loop HEIGHT times.  I read in ONE line of the picture each time through
  146.  * the loop.  I then loop again, disecting that line into the output file. I
  147.  * only go height-1 so I can once again terminate my array properly */
  148.  
  149.     if(rawhdr.width < 20) value = rawhdr.width;
  150.     else value = 30;
  151.     for(temp = 0;temp < rawhdr.height-1; temp++)
  152.         {
  153.         fread(picdata, rawhdr.width, 1, fp);
  154.         temp1=0;
  155.         while(temp1 < rawhdr.width)
  156.             {
  157.             for(z = 0;z < value;z++)
  158.                 {
  159.                 if(temp1 == rawhdr.width) break;
  160.                 fprintf(fp1, "%d,", picdata[temp1++]);
  161.                 }
  162.             fprintf(fp1, "\n");
  163.             }
  164.         }
  165. /* here is where I terminate the array, I just read in the last line and
  166.  * disect it until I have one left, then I print the last one with the closing
  167.  * bracket */
  168.  
  169.     fread(picdata, rawhdr.width, 1, fp);
  170.     temp1 = 0;
  171.     while(temp1 < (rawhdr.width-1))
  172.             {
  173.             for(z = 0;z < value;z++)
  174.                 {
  175.                 if(temp1 == (rawhdr.width-1)) break;
  176.                 fprintf(fp1, "%d,", picdata[temp1++]);
  177.                 }
  178.             fprintf(fp1, "\n");
  179.             }
  180.     fprintf(fp1, "%d };",picdata[temp1]);
  181. }
  182.  
  183. void help(int errorlevel)
  184. {
  185.     printf("\n");
  186.     printf("HSI2ARR -- Converts HSI Raw format to C Array\n");
  187.     printf("     By Darion (thimj@u.washington.edu)\n");
  188.     printf("─────────────────────────────────────────────\n");
  189.     printf("Usage: hsi2arr <input file> <output file>\n");
  190.     printf("Example: hsi2arr eddings.raw eddings.h\n");
  191.  
  192.     exit(errorlevel);
  193. }
  194.  
  195. /* here is that routine I mentioned above, pulls an integer out of a stream
  196.  * regardless of the HIGH or LOW position of the bytes, I guess some OS's
  197.  * differ in the way that they arrange the bytes of their integers */
  198.  
  199. int getWord(FILE *stream)
  200. {
  201.     register int temp;
  202.     temp=getc(stream) << 8;
  203.     return(getc(stream) | temp);
  204. }
  205.